/**
 * 地图总数据(Header)
 * name: 地图名称;
 * type: 2D_Nature：2D 自然地图，无反激光地图
 *       2D_Sign：2D 标记地图，有反激光地图
 *       2D_Trajecyory：2D 轨道地图，用于磁条导航
 *       2D_QRCode：2D 二维码地图
 * resolution: 地图分辨率;
 * reflector_diameter: 反光柱直径/反光板宽度;
 * map_version: 地图版本号，每保存一次，版本号加 1,从 0 开始;
 * map_line_speed: 小车默认地图路径线速度 m/s;
 * map_angle_speed: 小车默认地图路径角速度 rad/s;
 * min_pos: 地图最小点坐标;
 * max_pos: 地图最大的坐标;
 * map_adjust_line_speed: 小车切换导航方式调整位置时的线速度 m/s;
 * map_adjust_angle_speed: 小车切换导航方式调整位置时的角速度 rad/s;
 * support_type: 支持 AGV 类型，多个用，隔开，默认支持 all;
**/

/**
 * 路径点数据(Advanced_point)
 * id: 唯一标识;
 * class_name: LandMark：路径点;
 *             ChargePoint：充电点;
 *             HomePoint：充电房;
 *             ReturnPoint：返航点;
 * instance_name: 路径点名称;
 * navigation_laser: 0-不支持激光导航;
 *                   1-支持激光导航;
 * angle: 朝向角;
 * pos: 路径点坐标;
 * gyro: 0-不需要陀螺仪标定;
 *       1-需要陀螺仪标定;
 * allow_revolve: 0-不支持原地旋转;
 *                1-支持原地旋转;
 * spin_direction: clock：顺时针；
 *                 unclock：逆时针；
 *                 both：双向。
**/

/**
 * 路径数据(Advanced_curve)
 * 
 * id: 唯一标识
 * class_name: BezierPath：贝塞尔曲线
 *             straight_line：直线
 *             Convex：凸弧线
 *             concave_arc：凹弧线
 * instance_name: 路径名称
 * line_velocity:  线速度，0 - 使用机器人配置参数
 * Angle_velocity:  角速度，0 - 使用机器人配置参数
 * direction: forward 表示正走
 *           backward 表示倒走
 *            leftward 左横移
 *           rightward 右横移
 * Distance: 路径距离，默认 0，表示实际距离
 * is_navi_fix_angle(固定姿态模式): 0 - 不启用固定姿态；
 *                                 1 - 地图角度固定；
 *                                 2 - 路径夹角固定
 * nav_fix_angle: 地图角度固定：在地图中固定姿态的角度值。
 *                路径夹角固定：跟路径方向形成的夹角。
 * curve_type: bezier_curve 表示贝塞尔曲线
 *             straight_line 表示直线
 *             convex 表示凸弧线
 *             concave_arc 表示凹弧线
 * radian: 属性为弧线时需要配置弧度，单位 rad
 * start_pos: 路径起点坐标信息
 * end_pos: 路径终点坐标信息
 * control1_pos: 路径控制点 1 坐标
 * control2_pos: 路径控制点 2 坐标
 * Is_forbidden: 禁止标志位，0 表示可行，1 表示不可行，默认是 0
 * Navigate_way: 0：激光导航，1：二维码导航（默认 0）
 * laseravoiding: 路段上激光是否屏蔽，0：激光不屏蔽，1：激光屏蔽
 * Turn_angle: 舵轮角度，默认 0，单位 rad
**/

// 站点类型
var getType = new Map([
    ['LandMark', 0],
    ['ChargePoint', 2],
    ['ReturnPoint', 1]
])

// 路段类型
var getLineType = new Map([
    ['straight_line', 0],
    ['concave_arc', 1],
    ['convex', 2],
    ['bezier_curve', 3]
])

// 行驶方向
var getDirections = new Map([
    ['backward', 0],
    ['forward', 1],
    ['leftward', 2],
    ['rightward', 3]
])

export default function analysis(data: any, mapid: number) {
    let { advanced_point, advanced_curve } = data.MAP
    let stationList = analysisStation(advanced_point, mapid)
    let roadList = analysisRoad(data.MAP, mapid)

    return {
        mapId: mapid,
        stationList,
        roadList
    }
}

// 解析站点数据
function analysisStation(data, mapid) {
    let arr = []
    console.log(data);

    data.forEach((v, i) => {
        arr.push({
            name: v._instance_name,
            x: Number(v.pos._x).toFixed(3),
            y: Number(v.pos._y).toFixed(3),
            // angle: Number((v._angle * (180 / Math.PI)).toFixed(3)),
            angle: Number(v._angle).toFixed(3),
            status: 1,
            note: "",
            laser: Number(v._navigation_laser),
            qrcode: Number(v._navigation_qrcode),
            sort: i,
            type: getType.get(v._class_name) === 3 ? 0 : getType.get(v._class_name),
            mapid
        })
    });
    //   console.log(arr)
    return arr
}

// 解析路段数据
function analysisRoad(data, mapid) {
    let { advanced_point, advanced_curve } = data
    let arr = []

    advanced_curve.forEach((v, i) => {
        let start_pos = areCoordsEqual(advanced_point, v.start_pos)
        let end_pos = areCoordsEqual(advanced_point, v.end_pos)

        // 双向地图id会出现两次，单向只会出现一次
        if (arr.findIndex(x => { return x.no === v._id }) !== -1) {
            arr[arr.length - 1].direction = 2
            return arr[arr.length - 1].detailList.push(
                {
                    startstation: start_pos._instance_name,
                    endstation: end_pos._instance_name,
                    status: 1,
                    note: "",
                    speedlevel: "middle",
                    direction: getDirections.get(v._Direction)
                }
            )
        }

        arr.push({
            no: v._id,
            oldid: Number(v._id),
            roadname: `${start_pos._instance_name} - ${end_pos._instance_name}`,
            startstation: start_pos._instance_name,
            endstation: end_pos._instance_name,
            status: 1,
            note: "",
            direction: 1,
            linetype: getLineType.get(v._curve_type),
            detailList: [
                {
                    startstation: start_pos._instance_name,
                    endstation: end_pos._instance_name,
                    status: 1,
                    note: "",
                    speedlevel: "middle",
                    direction: getDirections.get(v._Direction)
                }
            ],
            mapid
        })

        // 当其为贝塞尔曲线时
        if (['bezier_curve', 'concave_arc', 'convex'].indexOf(v._curve_type) !== -1) {
            arr[arr.length - 1].assistList = [
                {
                    x: Number(v.control1_pos._x).toFixed(3),
                    y: Number(v.control1_pos._y).toFixed(3)
                },
                {
                    x: Number(v.control2_pos._x).toFixed(3),
                    y: Number(v.control2_pos._y).toFixed(3)
                }
            ]
        }

        // 当其为凹弧线、凸弧线时
        if (['convex', 'concave_arc'].indexOf(v._curve_type) !== -1) {
            // 将弧度值转换为角度值
            // 使用弧度与角度的转换公式：角度 = 弧度 * (180 / π)
            let angle = (Number(v._radian) * (180 / Math.PI))  // 将变量 v 的弧度值 _radian 转换为角度值并存储在变量 angle 中
            // let angle = Number(v._radian)
            arr[arr.length - 1].angle = Number(angle.toFixed(2))
        }
    })
    return arr
}

// 根据坐标找到对应站点
function areCoordsEqual(advanced_point, _pos) {
    let { _x, _y } = _pos.pos
    return advanced_point.find(j => { return Number(j.pos._x) === Number(_x) && Number(j.pos._y) === Number(_y) })
}